1. Field of the Invention
The present invention relates to distributed computer systems, and in particular, relates to the use of remote procedure call mechanisms in distributed computer systems.
2. Description of the Related Art
In a distributed computer system, efficiency can be enhanced by sharing of resources (e.g. a file system) among numerous computers in the system. In addition, multiple computers can be used cooperatively in such a system to perform a common task. A number of communication paradigms have been developed to structure a network of computers to allow these computers to work cooperatively or to share resources. Among these paradigms is the "client-server" model. In the client-server model, one or more computers (the "servers") are assigned to provide services which other computers (the "clients") in the distributed computer system may request, either by passing messages to the servers or by invoking remote procedure calls. In the client-server paradigm, the client initiates a service request, and the server responds to such service request.
A remote procedure call is a mechanism by which a program executing in a process space of one computer causes a procedure to be executed in a process space of another computer ("remote computer"). One implementation of the client-server paradigm has a client process invoke a remote procedure call to activate the requested service in a server process. A convenient implementation of the server process is a daemon process. A daemon process is a computer process which receives messages from other processes, and which, once started, is resident in the computer until a "kill" message is received from another process, a timer times out, or when the all expected messages are received. Such a daemon process is often used to manage a shared resource. For example, a daemon process for a print queue receives messages from processes which require the use of one or more printers associated with the print queue. To effectuate a print operation, a requesting process sends a print request to the daemon process which, if appropriate, would set up and schedule the necessary print processes to satisfy the print request. The daemon process provides efficiency, since tasks requiring printer-specific information are assigned to the daemon process and off-loaded from the requesting processes. A daemon process is said to be "sleeping" while waiting for a message from a requesting process, and is said to be "awaken" when performing its assigned task.
Modern software programs are designed to exploit the advantages of modularization and data abstraction. Modularization allows a complex system to be partitioned at defined functional interfaces into interrelated subsystems. Each subsystem's implementation complexity is thus shielded from ("transparent to") other subsystems, and can therefore be developed and modified to a large extent independently from other subsystems.
Data abstraction simplifies the task of programming by the use of high level data structures, which are logical or conceptual representation of the objects the data represent. Thus, data abstraction allows the programmer to manage data at a conceptual level, rather than managing data as a collection of primitive data types.
Ideally, suitable modularization should allow an application programmer to invoke services of the operating system, e.g. to request status of a print job, without knowledge of the intricacies as to how the service is procured or where the service provider is located. In addition, high level data structures support should be provided to allow an application program to interface with another program without dismantling the application program's high level data structure to lower level primitives.
Contrary to the goals of data abstraction and modularization, even though distributed computer systems have been used widely, remote procedure calls are implemented in language-dependent frameworks. Consequently, only relatively low level data structures can be passed between the computer processes involved in the remote procedure call, thereby requiring the application programmer to treat a distributed object specially. Such requirement defeats modularization.
Further, because a suitable mechanism for communicating high level data structures is unavailable, the data structure of an application program is often dismantled explicitly in the application program code to create the low level data structure necessary for communicating data across machine boundaries. The portability and reliability of such application programs are affected.
Thus, a mechanism of a high level of abstraction is desired to insulate application programs from having to set up for remote procedure calls. For example, remote procedure calls should be made transparent to the application programmer. That is, the mechanism should allow an application program to be written without knowledge or requirement that certain data structures of the application program are to be implemented on or be dependent upon resources controlled by a remote machine.